'use strict';

const { Service } = require('egg');
const dayjs = require("dayjs");
const {Op} = require("sequelize");
const ModelName = 'Cycle'
class RouterService extends Service {
    /**
     * 根据分页和搜索条件获取
     * @param {Object} where 查询用户的条件
     * @param {Number} page 当前分页
     * @param {Number} pageSize 当前页每页多少条
     */
    async getPage(where, page, pageSize) {
        return this.ctx.model[ModelName].findAndCountAll({
            where,
            offset: pageSize * (page - 1),
            limit: pageSize,
            order:[
                // id 降序
                ['start_time','ASC']
            ],
            include: [
                {
                    model: this.ctx.model.Ship,
                    as: 'ship',
                },
                {
                    model: this.ctx.model.Order,
                    as: 'orderList',
                },
                {
                    model: this.ctx.model.OrderUser,
                    as: 'orderUserList',
                }
            ],
            // 分页查询出很多数据
            distinct: true
        });
    }

    // 所有列表
    async allList(where) {
        return this.ctx.model[ModelName].findAll({
            where,
            order:[
                // id 降序
                ['create_time','DESC']
            ],
            include: [
                {
                    model: this.ctx.model.Ship,
                    as: 'ship',
                },
                {
                    model: this.ctx.model.Order,
                    as: 'orderList',
                    // include: [
                    //     {
                    //         model: this.ctx.model.User,
                    //         as: 'user',
                    //         attributes: ['id', 'nickname', 'phone']
                    //     }
                    // ]
                },
                {
                    model: this.ctx.model.OrderUser,
                    as: 'orderUserList',
                }
            ]
        });
    }
    async findOne(id) {
        return this.ctx.model[ModelName].findOne({
            where: {
                id,
            },
        });
    }

    /**
     * 创建
     * @param {*} data 角色信息
     */
    async batchCreate(data) {
        let startDate = dayjs(data.start_time).format('YYYY-MM-DD');
        let endDate = dayjs(data.end_time).format('YYYY-MM-DD');
        // 计算之间一共有几天为每天插入数据
        let diff = dayjs(endDate).diff(dayjs(startDate), 'day');
        let itemList = data.itemList;

        for (let i = 0; i <= diff; i++) {
            for (let j = 0; j < itemList.length; j++) {
                await this.ctx.model[ModelName].create({
                    ship_id: data.ship_id,
                    count: itemList[j].count,
                    price:data.price,
                    child_price: data.child_price,
                    duration: data.duration,
                    // 拼接日期+itemList中的时间
                    start_time: dayjs(dayjs(startDate).add(i, 'day').format('YYYY-MM-DD') + ' ' + dayjs(itemList[j].start_time).format('HH:mm:ss')),
                    end_time: dayjs(dayjs(startDate).add(i, 'day').format('YYYY-MM-DD') + ' ' + dayjs(itemList[j].end_time).format('HH:mm:ss')),
                });
            }
        }
        return true
    }
    async create(data) {
        return this.ctx.model[ModelName].create(data);
    }
    // 创建包船时间段
    async createCustom(data) {
        // 校验该时间段，三小时的排期是否存在THREE_HOUR冲突时间
        let ship = await this.ctx.model.Ship.findOne({
            where: {
                code: 'THREE_HOUR'
            }
        })
        if (ship) {
            let threeHourList = await this.ctx.model[ModelName].findAll({
                where: {
                    ship_id: ship.id,
                    [Op.or]: [
                        // 情况1：新时间段的开始时间在已有时间段内
                        {
                            start_time: { [Op.lte]: data.start_time },
                            end_time: { [Op.gte]: data.start_time }
                        },
                        // 情况2：新时间段的结束时间在已有时间段内
                        {
                            start_time: { [Op.lte]: data.end_time },
                            end_time: { [Op.gte]: data.end_time }
                        },
                        // 情况3：新时间段完全包含已有时间段
                        {
                            start_time: { [Op.gte]: data.start_time },
                            end_time: { [Op.lte]: data.end_time }
                        }
                    ]
                },
                include: [
                    {
                        model: this.ctx.model.Order,
                        as: 'orderList',
                    }
                ]
            })
            if (threeHourList && threeHourList.length > 0 && threeHourList.some(item => item.orderList.length > 0)) {
                throw new Error(`该时间段与${ship.name}行程时间冲突，请联系客服处理`);
            }
        }
        // 检查所有可能的时间冲突情况
        let list = await this.ctx.model[ModelName].findAll({
            where: {
                ship_id: data.ship_id,
                [Op.or]: [
                    // 情况1：新时间段的开始时间在已有时间段内
                    {
                        start_time: { [Op.lte]: data.start_time },
                        end_time: { [Op.gte]: data.start_time }
                    },
                    // 情况2：新时间段的结束时间在已有时间段内
                    {
                        start_time: { [Op.lte]: data.end_time },
                        end_time: { [Op.gte]: data.end_time }
                    },
                    // 情况3：新时间段完全包含已有时间段
                    {
                        start_time: { [Op.gte]: data.start_time },
                        end_time: { [Op.lte]: data.end_time }
                    }
                ]
            }
        });

        if (list && list.length > 0) {
            throw new Error('该时间段已被预约，请重新选择时间');
        }

        return this.create(data);
    }
    /**
     * 根据ID修改
     * @param {Number} id ID
     * @param {Object} data 要修改的信息
     */
    async update(id, data) {
        return await this.ctx.model[ModelName].update(data, { where: { id } });
    }

    /**
     * 根据id删除
     * @param {Number}
     */
    async deleteById(id) {
        return await this.ctx.model[ModelName].destroy({ where: { id } });
    }
}

module.exports = RouterService;
